package com.hutao.manage.util;

import java.math.BigDecimal;
import java.text.DecimalFormat;

public class NumUtil {
	 //默认除法运算精度     
    private   static   final   int   DEF_DIV_SCALE   =   10;     
  
  
  
    /**    
      *   提供精确的加法运算。    
      *   @param   v1   被加数    
      *   @return   两个参数的和    
      */     
  
    public   static   double   add(double   v1,double   v2){     
            BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));     
            BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));     
            return   b1.add(b2).doubleValue();     
    }     
    
    /**    
     *   提供精确的加法运算。    
     *   @param   v1   被加数    
     *   @return   两个参数的和    
     */     
 
   public   static   double   add(double   v1,double   v2,double v3){     
           BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));     
           BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));  
           BigDecimal   b3   =   new   BigDecimal(Double.toString(v3));  
           BigDecimal b4 = b1.add(b2);
           return   b4.add(b3).doubleValue();     
   }     
  
    /**    
      *   提供精确的减法运算。    
      *   @param   v1   被减数    
      *   @param   v2   减数    
      *   @return   两个参数的差    
      */     
  
    public   static   double   sub(double   v1,double   v2){     
            BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));     
            BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));     
            return   b1.subtract(b2).doubleValue();     
    }       
  
    /**    
      *   提供精确的乘法运算。    
      *   @param   v1   被乘数    
      *   @param   v2   乘数    
      *   @return   两个参数的积    
      */     
  
    public   static   double   mul(double   v1,double   v2){     
            BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));     
            BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));     
            return   b1.multiply(b2).doubleValue();     
    }     
  
  
  
    /**    
      *   提供（相对）精确的除法运算，当发生除不尽的情况时，精确到    
      *   小数点以后10位，以后的数字四舍五入。    
      *   @param   v1   被除数    
      *   @param   v2   除数    
      *   @return   两个参数的商    
      */     
  
    public   static   double   div(double   v1,double   v2){     
            return   div(v1,v2,DEF_DIV_SCALE);     
    }     
  
  
  
    /**    
      *   提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指    
      *   定精度，以后的数字四舍五入。    
      *   @param   v1   被除数    
      *   @param   v2   除数    
      *   @param   scale   表示表示需要精确到小数点以后几位。    
      *   @return   两个参数的商    
      */     
  
    public   static   double   div(double   v1,double   v2,int   scale){     
            if(scale<0){     
                    throw   new   IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");     
            }     
            BigDecimal   b1   =   new   BigDecimal(Double.toString(v1));     
            BigDecimal   b2   =   new   BigDecimal(Double.toString(v2));     
            return   b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();     
    }     
  
  
  
    /**    
      *   提供精确的小数位四舍五入处理。    
      *   @param   v   需要四舍五入的数字    
      *   @param   scale   小数点后保留几位    
      *   @return   四舍五入后的结果    
      */     
  
    public   static   double   round(double   v,int   scale){     
            if(scale<0){     
                    throw   new   IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");     
            }     
            BigDecimal   b   =   new   BigDecimal(Double.toString(v));     
            BigDecimal   one   =   new   BigDecimal("1");     
            return   b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();     
    }
    
    
    /**
     * 格式化double为两位小数
     * @param v1
     * @return
     */
    public static  double format(double v1) {

    	DecimalFormat    df   = new DecimalFormat("######0.00"); 
    	return Double.parseDouble(df.format(v1));
    }
    
    
    public static int getAvgNum(int avgNum) {
    	
    	if(avgNum<=2000){
    		return 2000;
    	}else if(avgNum>2000 && avgNum <= 2500) {
    		return 2500;
    	}else if(avgNum>2500 && avgNum <= 3000) {
    		return 3000;
    	}else if(avgNum>3000 && avgNum <= 3500) {
    		return 3500;
    	}else if(avgNum>3500 && avgNum <= 4000) {
    		return 4000;
    	}else if(avgNum>4000 && avgNum <= 4500) {
    		return 4500;
    	}else if(avgNum>4500 && avgNum <= 5000) {
    		return 5000;
    	}else if(avgNum>5000 && avgNum <= 5500) {
    		return 5500;
    	}else if(avgNum>5500 && avgNum <= 6000) {
    		return 6000;
    	}else if(avgNum>6000 && avgNum <= 6500) {
    		return 6500;
    	}else if(avgNum>6500 && avgNum <= 7000) {
    		return 7000;
    	}else if(avgNum>7000 && avgNum <= 7500) {
    		return 7500;
    	}else if(avgNum>7500 && avgNum <= 8000) {
    		return 8000;
    	}else if(avgNum>8000 && avgNum <= 8500) {
    		return 8500;
    	}else if(avgNum>8500 && avgNum <= 9000) {
    		return 9000;
    	}else if(avgNum>9000 && avgNum <= 9500) {
    		return 9500;
    	}else if(avgNum>9500 && avgNum <= 10000) {
    		return 10000;
    	}else {
    		return 12000;
    	}
    }
    
    
    public static int getTotalNum(int totalNum) {
    
    	if(totalNum<=10000){
    		return 10000;
    	}else if(totalNum>10000 && totalNum <= 20000) {
    		return 20000;
    	}else if(totalNum>20000 && totalNum <= 30000) {
    		return 30000;
    	}else if(totalNum>30000 && totalNum <= 40000) {
    		return 40000;
    	}else if(totalNum>40000 && totalNum <= 50000) {
    		return 50000;
    	}else if(totalNum>50000 && totalNum <= 60000) {
    		return 60000;
    	}else if(totalNum>60000 && totalNum <= 70000) {
    		return 70000;
    	}else if(totalNum>70000 && totalNum <= 80000) {
    		return 80000;
    	}else if(totalNum>80000 && totalNum <= 90000) {
    		return 90000;
    	}else if(totalNum>90000 && totalNum <= 100000) {
    		return 100000;
    	}else if(totalNum>100000 && totalNum <= 110000) {
    		return 110000;
    	}else if(totalNum>110000 && totalNum <= 120000) {
    		return 120000;
    	}else if(totalNum>120000 && totalNum <= 130000) {
    		return 130000;
    	}else if(totalNum>130000 && totalNum <= 140000) {
    		return 140000;
    	}else if(totalNum>140000 && totalNum <= 150000) {
    		return 150000;
    	}else if(totalNum>150000 && totalNum <= 160000) {
    		return 160000;
    	}else if(totalNum>160000 && totalNum <= 170000) {
    		return 170000;
    	}else if(totalNum>170000 && totalNum <= 180000) {
    		return 180000;
    	}else if(totalNum>180000 && totalNum <= 190000) {
    		return 190000;
    	}else if(totalNum>190000 && totalNum <= 200000) {
    		return 200000;
    	}else {
    		return 21000;
    	}
    }
    
    
    

    
    
    public static void main(String[] args) {
    	System.out.println(format(div(136,3490,5)*100));
	}

}
